Fixes #1662.

PR #1621 made RDoc::Constant#is_alias_for fall through to a lazy
find_alias_for lookup that returned whatever class the constant's value
named in the current store. The lazy result then flowed into
RDoc::ClassModule#update_aliases, which unconditionally wrote a dup'd
alias copy into @store.classes_hash, with two safeguards present
elsewhere bypassed:

* Context#add_module_alias refuses to clobber an existing class entry
  (the historic BasicObject = BlankSlate guard), but update_aliases
  did not.
* The prism parser only registers an alias when the constant has
  document_self set (so :nodoc: is honored), but the lazy resolver
  ignored it.

In combination these meant `Foo = Bar # :nodoc:`, where a real `Foo`
class was parsed elsewhere, would silently replace the real class's
documentation with an alias copy of `Bar` -- the literal failure mode
in #1662 (the prism shim's `Ripper = Prism::Translation::Ripper`
clobbering the real Ripper class docs).

Architectural fix
-----------------

Split RDoc::Constant#is_alias_for back into a pure accessor and a
separate Constant#resolved_alias_target lookup. is_alias_for now
returns only what was recorded explicitly (by Context#add_module_alias,
by ClassModule#update_aliases, or by ri marshal load) and never mutates
state. resolved_alias_target is the opportunistic forward-reference
lookup, used only by update_aliases as a fallback when no explicit
alias is recorded; it honors document_self so :nodoc: constants
don't lazy-resolve.

The lazy lookup itself uses a new Constant#is_alias_for_path attribute
populated by the parsers, instead of regex-matching #value at lookup
time. Both the prism parser (via ConstantReadNode/ConstantPathNode
detection in constant_path_string) and the legacy ripper parser (via
on_const-only token accumulation in parse_constant_body) already know
whether the RHS is a constant reference at parse time; we now propagate
that explicitly rather than rediscovering it from a stringly-typed
value.

Mechanical fix
--------------

ClassModule#update_aliases falls back to const.resolved_alias_target
when const.is_alias_for is unset, and gates the destination write
behind a collision check that mirrors the one in
Context#add_module_alias: skip if classes_hash/modules_hash already
holds a real (non-alias) class at the destination name. The guard now
applies uniformly to both the explicit and lazy paths.

When the fallback resolves a forward-reference target, the resolved
class is also written back to const.is_alias_for so downstream
consumers (RDoc::Stats#report_constants, RDoc::Constant#marshal_dump)
observe the alias relationship the lazy lookup found -- otherwise
forward-ref aliases get reported as undocumented and the alias slot is
serialized as nil into ri data.

For that guard to compose with add_module_alias's pre-registration
flow (which already places an alias copy at the destination expecting
update_aliases to overwrite it with the properly-marked version),
add_module_alias now sets is_alias_for on the alias copy at creation
time. Existing alias copies are therefore distinguishable from real
classes by the unconditional guard.

Tests
-----

Parser-level regressions cover :nodoc: assignment, real-class
collision, the combined :nodoc:-plus-collision scenario from #1662,
the :stopdoc:/:startdoc: workaround path, an explicit alias followed
by a same-named class re-open (which under the new guard preserves
both the alias target's methods and the methods added by the re-open),
and the post-Store#complete is_alias_for persistence on a
forward-reference alias. Each asserts both the negative (the would-be
alias didn't clobber) and the positive (the alias target keeps its
own methods and aliases list). Unit tests on update_aliases assert
the same. The two existing PR #1621 tests
(test_constant_alias_reverse_order, test_repeated_constant_alias) are
updated to exercise the renamed resolved_alias_target API; the
underlying forward-reference behavior is preserved.

Codex flagged a ripper-only path where Constant#is_alias_for_path stays
nil for +Foo = Bar # comment+: parse_constant_body's on_const branch
only fires create_module_alias when the const token is followed by
on_nl/EOF, so the trailing comment short-circuits the recording. Pre-PR
this was masked by Constant#find_alias_for's lookup-time regex on
+value+, which this PR removes.

Skip the actual fix -- the ripper parser is on its way out (loads with
a deprecation banner, opt-in via RDOC_USE_RIPPER_PARSER=1) and isn't
worth a backstop. Keep the test in the shared parser-mixin
(RDocParserPrismTestCases) so prism is still guarded against the same
shape, and omit it under the legacy ripper variant.

* update_aliases persisted const.is_alias_for from the lazy
  resolved_alias_target lookup before the collision guard ran. When
  a real class already lived at the destination, the alias copy was
  correctly skipped but the constant was still mismarked, so
  Stats#report_constants and Constant#marshal_dump observed the
  alias relationship for an object the guard had just protected.
  Move the persistence below the guard so skipped aliases also skip
  the persistence.

* In the prism parser, add_constant resolved owner/name from the
  full constant path but called @container.add_module_alias on the
  outer lexical container. For Outer::Foo = Bar parsed at top level,
  this registered the alias copy as classes_hash['Foo'] (using the
  container's child_name) instead of 'Outer::Foo', leaving a stray
  top-level entry that update_aliases later duplicated under the
  correct namespace. Call owner.add_module_alias instead. The
  ripper parser already handles this correctly because parse_constant
  reassigns its container to the resolved nested module.

Tests:
* test_constant_alias_collision_does_not_mismark_constant_as_alias
  asserts Foo's constant ends up with is_alias_for=nil when a real
  Foo class already exists alongside Foo = Bar.
* test_qualified_constant_alias_registers_in_owner_namespace
  asserts Outer::Foo = Bar registers only at classes_hash['Outer::Foo']
  and does not leak a top-level Foo entry.